{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第6章 向量化\n",
    "\n",
    "本章主要介绍PyTorch中的向量化思想。其中6.1节和6.2节介绍向量化的基本概念和常用的广播法则；6.3节介绍PyTorch中的高级索引，这也是向量化思想的重点，通过高级索引操作可以简化向量的计算。\n",
    "\n",
    "## 6.1 向量化简介\n",
    "\n",
    "向量化计算是一种特殊的并行计算方式，指对不同的数据执行同样的一个或一批指令，或者把指令应用到一个数组或向量上，从而将多次for循环操作变成一次计算。一般来说，程序在同一时间内只执行一个操作，而并行计算可以在同一时间内执行多个操作。向量化计算的关键是分析张量的形状，一旦确定了张量形状，如何操作就呼之欲出了。\n",
    "\n",
    "同时，向量化操作可以极大地提高科学运算的效率。Python本身是一门高级语言，使用简便，但其中存在着许多低效的操作，例如for循环等。因此，在科学计算程序中应当极力避免使用Python原生的for循环，而尽量使用向量化的数值运算，下面举例说明：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch as t\n",
    "def for_loop_add(x, y):\n",
    "    result = []\n",
    "    for i, j in zip(x, y):\n",
    "        result.append(i + j)\n",
    "    return t.tensor(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 loops, best of 3: 1.29 ms per loop\n",
      "100 loops, best of 3: 4.36 µs per loop\n"
     ]
    }
   ],
   "source": [
    "x = t.zeros(100)\n",
    "y = t.ones(100)\n",
    "%timeit -n 100 for_loop_add(x, y)\n",
    "%timeit -n 100 (x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从上面的例子中可以看出，for循环和向量化计算之间有着数百倍的速度差距，因此在实际使用中读者应该尽量调用内建函数（buildin-function）。内建函数底层由C/C++实现，在实现中均体现了向量化计算的思想，并通过底层优化实现了高效计算。在日常编程中读者最好养成向量化的编程习惯，避免对较大的Tensor进行逐元素的遍历操作，从而提高程序的运行效率。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.2 广播法则\n",
    "\n",
    "广播法则（broadcast）是科学计算中经常使用的一个技巧，它在快速执行向量化计算的同时不会占用额外的内存/显存。PyTorch和NumPy中的广播法则定义如下。\n",
    "\n",
    "（1）所有输入数组都与维度（n_dim）最大的数组看齐，维度不足的部分在前面加1补齐。比如，两个数组形状分别为(3,4)和(2,3,1)，前一个会自动将形状补齐为(1,3,4)。\n",
    "\n",
    "（2）两个数组要么在某一个维度的尺寸一致，要么其中一个数组在该维度的尺寸为1，否则不能计算。比如，形状为(1,3,4)和(2,3,1)的两个数组可以计算，而形状为(1,3,4)和(2,3,2)的两个数组不能计算。\n",
    "\n",
    "（3）如果输入数组某个维度的尺寸为1，那么计算时该数组会沿此维度复制扩充成目标的形状。比如，形状为(1,3,4)和(2,3,1)的两个数组会复制扩充成(2,3,4)。\n",
    "\n",
    "虽然PyTorch已经支持了自动广播法则，但是笔者还是建议初学者通过以下两种方式的组合，手动实现广播法则，这样更加直观，也更不容易出错。\n",
    "\n",
    "- `unsqueeze`、`view`或者`tensor[None]`：为数组的某一维度补1，实现法则（1）。\n",
    "- `expand(*new_size)`或者`expand_as(tensor_b)`：重复数组，实现法则（3）。因为`expand`操作不会复制数组，所以不会占用额外的空间。\n",
    "\n",
    "注意：虽然`repeat`可以实现与`expand`类似的功能，但是`expand`是在已经存在的Tensor上创建一个新的视图（view），而`repeat`会将相同数据复制多份，因而占用额外的内存空间。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "原始储存占用：3\n",
      "expand储存占用：3\n",
      "repeat储存占用：27\n"
     ]
    }
   ],
   "source": [
    "# 比较expand和repeat的内存占用情况\n",
    "a = t.arange(3).view(1, 3)\n",
    "print(\"原始储存占用：\" + str(a.storage().size()))\n",
    "# expand不额外占用内存，只返回一个新的视图\n",
    "b = a.expand(3, 3)\n",
    "print(\"expand储存占用：\" + str(b.storage().size()))\n",
    "# repeat复制了原始张量\n",
    "c = a.repeat(3, 3)\n",
    "print(\"repeat储存占用：\" + str(c.storage().size()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 3, 2])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.ones(3, 2)\n",
    "b = t.zeros(2, 3, 1)\n",
    "\n",
    "# 自动广播法则\n",
    "# 第一步：a是2维的，b是3维的，所以先在较小维度的a前面补1个维度，\n",
    "#       即：a.unsqueeze(0)，a的形状变成(1，3，2)，b的形状是(2，3，1),\n",
    "# 第二步：a和b在第一维和第三维形状不一样，其中一个为1，\n",
    "#       即：可以利用广播法则扩展，两个形状都变成了(2，3，2)\n",
    "(a + b).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[1., 1.],\n",
       "         [1., 1.],\n",
       "         [1., 1.]],\n",
       "\n",
       "        [[1., 1.],\n",
       "         [1., 1.],\n",
       "         [1., 1.]]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 手动广播法则，下面两行操作是等效的\n",
    "# a.view(1, 3, 2).expand(2, 3, 2)+b.expand(2, 3, 2)\n",
    "a[None].expand(2, 3, 2) + b.expand(2, 3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 6.3 索引操作\n",
    "\n",
    "索引（indexing）是高维数组中的常用操作，形如`tensor[indices]`，根据`indices`的不同类型，索引又可以分为Tensor基本索引（Basic Slicing and Indexing）和高级索引（Advanced Indexing）。本节将先从Tensor的底层实现开始，对比介绍基本索引和高级索引的相关用法，帮助读者建立向量化思想。\n",
    "\n",
    "\n",
    "### 6.3.1 Tensor的底层实现\n",
    "\n",
    "如果读者要充分理解PyTorch的索引操作，那么必须熟悉Tensor的底层实现。在3.1.3节中我们简要地介绍了Tensor的基本结构，这里我们深入分析一下它的底层原理。\n",
    "\n",
    "Tensor的底层使用C/C++实现，它可以用于存储数据，还可以定义如何对数据进行操作。Tensor与Python list最大的区别是：Tensor利用一个连续的内存区域去存储数据，这些数据都未经过封装；list中的每个数据都会被封装成PyObject对象，每个对象独立分配内存并离散地存储在内存当中。\n",
    "\n",
    "在PyTorch底层使用`Storage`类来管理Tensor的内存区域，它使用一个一维数组来存储数据。Tensor通过修改内部的size、storage_offset和stride属性让这个一维数组“看起来像一个多维数组”（获得多个Tensor的实例），实际上这些Tensor指向同一个`Storage`区域，下面举例说明："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(6).view(3, 2)\n",
    "b = a.reshape(2, 3)   # 改变形状\n",
    "c = a.transpose(1, 0) # 转置\n",
    "d = a[:2, 1]          # 切片\n",
    "# a，b，c，d四个实例指向同一个storage\n",
    "a.storage().data_ptr() == b.storage().data_ptr() == c.storage().data_ptr() == d.storage().data_ptr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 2]) 0 (2, 1)\n",
      "torch.Size([2, 3]) 0 (3, 1)\n",
      "torch.Size([2, 3]) 0 (1, 2)\n",
      "torch.Size([2]) 1 (2,)\n"
     ]
    }
   ],
   "source": [
    "# 发生改变的实际是三个内部属性：size，storage_offset和stride\n",
    "print(a.size(), a.storage_offset(), a.stride())\n",
    "print(b.size(), b.storage_offset(), b.stride())\n",
    "print(c.size(), c.storage_offset(), c.stride())\n",
    "print(d.size(), d.storage_offset(), d.stride())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "关于这三个属性的说明如下。\n",
    "\n",
    "（1）size：控制Tensor每个维度上的取值范围，`reshape`操作、切片操作等都会修改Tensor实例的size属性。\n",
    "\n",
    "（2）storage_offset：Tensor开始元素对应存储区Storage的索引，因为部分Tensor实例只使用了一部分Storage，所以该属性能控制每个实例的起始位置。\n",
    "\n",
    "（3）stride：一个元组，stride的第k个元素表示Tensor的第k个维度中两个元素之间的内存间隔，这一概念使得Tensor的高级索引运算变得更加高效。\n",
    "\n",
    "![图6-1  Tensor的底层结构](imgs/Tensor_basic_structure.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "图6-1解释了一个高维Tensor是怎样从一个一维数组上存取数据的。我们可以通过storage_offset属性和stride属性，结合维度信息计算出任意位置元素在一维Storage上的索引offset，计算方法如式(6.1)所示。\n",
    "\n",
    "$$\\text{offset}=\\sum_{k=0}^{N-1}\\text{stride}_{k}\\times \\text{dim}_{k}+\\text{storage_offset}\\tag{6.1}$$\n",
    "\n",
    "其中，$\\text{dim}$表示所取元素的所在的维度。下面举例说明如何应用该式进行计算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 0,  1,  2,  3],\n",
       "         [ 4,  5,  6,  7],\n",
       "         [ 8,  9, 10, 11]]), torch.Size([3, 4]), 0, (4, 1))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(12).view(3, 4)\n",
    "a, a.size(), a.storage_offset(), a.stride()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果想要获取第二行第三列的元素$a[1,2]$，那么可以通过式(6.1)得出：$\\text{offset}=4\\times1+1\\times2+0=6$，也就是Storage中的第7个元素，这与$a[1,2]$得到的值相同。stride元组的计算极为简单，它可以视为多维数组向一维数组映射的权重，它的取值只与当前Tensor实例的size属性有关，计算方法如式(6.2)所示。\n",
    "\n",
    "$$\\text{stride}_k=\\prod_{j=k+1}^{N-1} \\text{DimNum}_{j}\\tag{6.2}$$\n",
    "\n",
    "其中，$\\text{DimNum}_{j}=\\text{self.shape}[j]$，stride元组的末尾元素默认为1。\n",
    "\n",
    "注意：必须在`tensor.is_contiguous=True`的时候，才可以使用这个式(6.2)计算$\\text{stride}$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60, 20, 5, 1)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a的size设为2×3×4×5\n",
    "a = t.rand(2, 3, 4, 5)\n",
    "# 可以通过式(6.2)计算得到，stride0=3×4×5=60，stride1=4×5=20，stride2=5，stride3=1\n",
    "a.stride()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "总结：对Tensor的许多操作都可以通过改变Tensor的size、stride、offset等属性实现，更改这些属性前后的Tensor共享同一个存储区域，可以节省内存。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.3.2 基本索引\n",
    "\n",
    "\n",
    "PyTorch中Tensor的索引和NumPy数组的索引类似，通过索引操作可以定位到数据具体的位置。基本索引是将Python中的切片概念扩展到了N维的形式。通过基本索引生成的所有Tensor都是原始Tensor的视图（view），它们和原始Tensor共享Storage。基本索引有以下几种形式，它们适用于每个维度的基本切片操作。\n",
    "\n",
    "（1）Tuple对象`Tensor[(IntA, IntB, IntC)]`或`Tensor[IntA, IntB, IntC]`：在索引中直接使用一个元组序列（tuple）对Tensor中数据的具体位置进行定位，也可以直接使用多个整数（元组序列省略括号的形式），后者是前者的语法糖。 \n",
    "\n",
    "（2）Slicing对象`Tensor[start:stop:step]`：切片对象`start:stop:step` 代表从`start`开始，每隔`step`个元素取一个，直到`stop`。这种形式有几种特殊情况，如`start:`，`:stop`，`start:stop`，`::step`和`:`。\n",
    "\n",
    "（3）省略号对象（`...`）：在索引中常用省略号（ellipsis）来代表一个或多个维度的切片，等效于一个或多个`:`。\n",
    "\n",
    "（4）`None`对象：与NumPy中的`newaxis`相同，`None`在PyTorch索引中起到增加一个维度的作用。\n",
    "\n",
    "\n",
    "下面举例说明这几种基本索引的使用方式。\n",
    "\n",
    "#### Tuple对象\n",
    "\n",
    "元组序列的操作形如`Tensor[(IntA, IntB, IntC)]`或`Tensor[IntA, IntB, IntC]`，后者是前者的语法糖。其中，IntA，IntB和IntC分别代表着三个维度的下标。如果下标的数目，少于Tensor的维度数，我们默认在后面加`:`，即用切片选择剩下的维度。`Tensor[IntA, IntB]`等价于`Tensor[IntA, IntB, :]`。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1,  2,  3,  4],\n",
       "        [ 5,  6,  7,  8],\n",
       "        [ 9, 10, 11, 12]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(1, 13).view(3, 4)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(7)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 提取位置第二行，第三列的元素, 等价于a[(1, 2)]（保留括号的元组形式）\n",
    "a[1, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([5, 6, 7, 8])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 固定第一个维度，提取第二个维度上的切片（省略第二个参数），等价于a[1,:]\n",
    "a[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意：`a[(0, 1)]`与`a[[0, 1]]`、`a[(0, 1),]`并不等价，后面两个索引用作选取第1，2行元素，它们不属于基本索引，而属于高级索引的范畴，这部分内容将在6.3.3节中进行讲解。\n",
    "\n",
    "#### Slicing对象\n",
    "\n",
    "切片对象的基本语法形式为：`start:stop:step`，`start`是起始索引，`stop`是终止索引，`step`是步长（`step>0`）。从`start`开始，每隔`step`个元素取一个，直到`stop`。取值范围包括`Tensor[start]`但不包括`Tensor[stop]`。切片对象有以下几种特殊情况/变形（假设，N是当前维度的大小）。\n",
    "\n",
    "- `start:stop`，默认step=1。\n",
    "- `start:`，默认stop=N，step=1。\n",
    "- `:stop`，默认start=0，step=1。\n",
    "- `::step`，等价于`0:N:step`。\n",
    "- `:`或`::`，全选这一维度，等价于`0:N:1`。\n",
    "- `start`或`stop`为负数，等价于`N-start`或`N-stop`。\n",
    "- `step`为负数，意思是反向索引，NumPy支持，但是PyTorch不支持。\n",
    "- tuple索引可以看成是切片索引的特例，比如`Tensor[IntA, IntB, IntC]`，近似但不等于`Tensor[IntA:IntA+1, IntB:IntB+1, IntC:IntC+1]`。\n",
    "- `...`代表一个或多个`:`，具体代表多少个`:`，取决于数组的维度。最终的索引个数和数组维度数一致。 \n",
    "- 形如`Tensor[idx1, idx2]`, 如果idx的数目小于Tensor的维度（Tensor.ndim），默认在后面补多个`:`或一个`...`。这一点对基本索引和高级索引都适用。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 3, 5, 7])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(10)\n",
    "a[1:8:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([5, 7]), tensor([5, 7]))"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# start或stop为负数\n",
    "a[-5:-1:2], a[(10-5):(10-1):2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([8, 5]), tensor([8, 5]), tensor([8, 5]))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#step为负数，只有numpy支持\n",
    "a_numpy = a.numpy()[8:2:-3]\n",
    "# PyTorch可以用t.flip函数，注意：下标需手动计算。flip函数创建新Tensor，不共享存储\n",
    "a_tensor = t.flip(a[5:9:3], [0])\n",
    "# 或者用t.arange, 这种方式属于高级索引\n",
    "a_tensor_2 = a[t.arange(8, 2, -3)]\n",
    "\n",
    "a_numpy, a_tensor, a_tensor_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 56, 224])\n",
      "torch.Size([3, 56, 224])\n"
     ]
    }
   ],
   "source": [
    "a = t.rand(3, 224, 224)\n",
    "print(a[:, 0:224:4, :].shape) # 第二个维度间隔切片\n",
    "print(a[:, ::4].shape) # 默认在后面缺失的维度补`:`全选。另默认start=0，stop=224"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[ 6,  7],\n",
       "         [ 8,  9],\n",
       "         [10, 11]]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(12).view(2, 3, 2)\n",
    "a[1:2] # 等价于a[1:2, :, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意：当索引为整数`i`和切片对象`i:i+1`时，虽然它们返回的值是相同的，但是得到的索引结果维度是不同的。直接使用整数`i`作为索引会比使用切片对象`i:i+1`作索引少一个维度。如果原始Tensor的维度是1，那么使用整数作为索引后返回的是一个标量值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([2, 2]) torch.Size([2, 1, 2])\n"
     ]
    }
   ],
   "source": [
    "# 使用整数作索引\n",
    "a_int = a[:, 1]\n",
    "# 使用切片对象作索引\n",
    "a_slice = a[:, 1:2]\n",
    "print(a_int.shape, a_slice.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "省略号`...`表示可以省略任意多个`:`表示的维度，一般情况下，一个索引中只会使用一次`...`。至于`...`到底代表了多少个`:`，取决于在它前面和后面各有多少个索引元素，最终总共索引元素的个数要等于数组的维度。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 6,  8, 10])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a是三维数组\n",
    "a[1:2, ...]  # 等价于a[1:2,:,:]，补两个 :\n",
    "a[1, ..., 0] # 等价于a[1,:,0], 补 一个 :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `None`索引\n",
    "\n",
    "`None`索引常用于在结果Tensor上扩展一个新的维度，增加的这个维度正好是`None`索引的位置。在PyTorch的源码中，`None`索引就经常被使用。`None`索引可以直观地表示维度的扩展，在广播法则中充当1的作用。使用`None`索引，本质上与使用`unsqueeze`函数是等价的，都能起到扩展维度的作用。但是，在维度较多的情况下，或者需要对多个维度进行扩展再进行矩阵计算时，使用`None`索引会更加清晰直观。因此，笔者强烈推荐使用`None`索引进行维度的扩展，下面举例说明："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 2, 3, 4, 5])\n",
      "torch.Size([1, 2, 3, 4, 5])\n"
     ]
    }
   ],
   "source": [
    "a = t.rand(2, 3, 4, 5)\n",
    "# 在最前面加一个维度，下面两种写法等价\n",
    "print(a.unsqueeze(0).shape)\n",
    "print(a[None,...].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 1, 3, 1, 4, 1, 5])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 在原有的四个维度中均插入一个维度，成为（2,1,3,1,4,1,5）\n",
    "# unsqueeze方法，每成功增加一个维度，需要重新计算下一个需要增加的维度位置\n",
    "b = a.unsqueeze(1).unsqueeze(3).unsqueeze(5)\n",
    "b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 1, 3, 1, 4, 1, 5])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# None索引方法，直接在需要增加的维度上填写None即可\n",
    "a[:,None,:,None,:,None,:].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "下面再例举一个使用`None`索引的例子。假设Tensor $a$是一组图像的feature maps经过全连接层后的结果，维度是$\\text{batch_size}\\times \\text{features}$，现在需要构建一个每两张图像之间的关系矩阵，读者可以思考一下如何使用`None`索引进行构建。\n",
    "\n",
    "处理这样一个问题，最直观的想法就是进行矩阵的乘法：将n×1维的矩阵与1×n维的矩阵相乘，结果就是n×n维的矩阵。因此，将Tensor $a$的第二个维度进行扩展并转置得到$a^T$，再使用矩阵的乘法即可："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([16, 256, 256])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 假设batch_size为16，features为256\n",
    "a = t.arange(16 * 256).view(16, 256)\n",
    "a1 = a.unsqueeze(1)\n",
    "a_T = a1.transpose(2, 1)\n",
    "a_matrix = a_T @ a1 # @表示矩阵的乘法\n",
    "a_matrix.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用`None`索引和广播法则解决这个问题将更加地直观："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([16, 256, 256]), torch.Size([16, 256, 256]))"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a[:,:,None] * a[:,None,:]\n",
    "c = a[:,None,:] * a[:,:,None]\n",
    "# 读者可以思考一下，b和c有什么区别？\n",
    "b.shape, c.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert t.equal(b, c)\n",
    "assert t.equal(a_matrix, b)\n",
    "# 没有触发异常，说明两种方式得到的结果是一样的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从上面的结果可以看出，$b$和$c$虽然写法不一样，但是最终结果是一样的。这是因为使用`None`索引进行维度扩展时，扩展的维度是1。当维度中有1存在时，Tensor相乘会触发广播法则，并在计算的时候自动填充，所以最终的结果是一致的。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "相比于高级索引，基本索引生成的所有Tensor都是原始Tensor的视图，它们和原始Tensor共享Storage。基本索引只会改变stride、offset等属性，然后返回原始Tensor的视图，下面举例说明："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(12).view(3, 4)\n",
    "b = a[1:, None] # 基本索引得到b\n",
    "a.storage().data_ptr() == b.storage().data_ptr() # a和b共享Storage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# 基本索引只是返回了一个新的视图，具有不一样的stride、offset等属性\n",
    "print(a.storage_offset() == b.storage_offset())\n",
    "print(a.stride() == b.stride())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "至此，我们介绍了PyTorch中的基本索引操作，下面我们将介绍更能体现向量化思想的高级索引操作，读者需要注意区分二者之间的不同。\n",
    "\n",
    "### 6.3.3 高级索引\n",
    "\n",
    "与基本索引相比，高级索引的触发条件不同，返回值也有所不同。高级索引的基本要求是`Tensor[idx1, idx2, ...]`的索引元素（idx）中至少包含一个Tensor或Tuple/List。常见的高级索触发条件有以下三种。再次强调 `tensor[Int1, Int2]` 等价于 `tensor[(Int1, Int2)]`，前者是后者的语法糖。\n",
    "\n",
    "（1）索引是Tensor。索引是一个包括整数类型或者布尔类型的Tensor。\n",
    "\n",
    "（2）索引是List，如`Tensor[[0,1]]`。注意和`Tensor[(0,1)]` 进行区别，后者是基本索引。\n",
    "\n",
    "（3）索引是Tuple并且里面至少包含另一个Tuple/List或者Tensor，如 `Tensor[1, [1,2,3]]`。\n",
    "\n",
    "（4）特例：为了保持与通用用法的向后兼容，如果索引对象是任何包含切片对象、省略号对象或`None`对象的非张量序列（如List），而不是整数类型的Tensor，那么会触发基本索引，而不是高级索引。这种情况比较少见，也不建议使用。\n",
    "\n",
    "\n",
    "注意：高级索引的返回值是原始Tensor的拷贝（copy）而不是视图（view），这是和基本索引最重要的不同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([3])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(12).view(2, 2, 3)\n",
    "a[0, 1].shape # 基本索引，等价于a[(0, 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 2, 3])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[[0, 1]].shape # 高级索引，索引是List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 2, 3])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[t.tensor([0, 1])].shape # 高级索引，索引是Tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 3])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[([0, 1], 1)].shape # 高级索引，索引是Tuple但是包含Tuple/List/Tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 2, 3])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[[0, None]].shape # 特殊情况，None触发基本索引，等价于a[0, None]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Integer Array Indexing\n",
    "\n",
    "\n",
    "这里我们主要介绍高级索引的第一种情况，也就是索引是一个整数数组（Integer Array Indexing），上面给的例子是这一小节的特例。\n",
    "\n",
    "整数数组索引可以根据$N$维索引选取数组中的任意项。一般情况下，整数数组索引需要提前确定输入输出Tensor的形状，这是因为所有的整数索引都有一个相对固定的模式：$\\text{tensor}[\\text{index}_1, \\text{index}_2, ..., \\text{index}_N]$。\n",
    "\n",
    "其中，$N$的大小必须小于等于这个Tensor的维度（`Tensor.ndim`）。如果经过索引操作后得到的Tensor形状是$M_1 \\times M_2 \\times ... \\times M_K$，那么这个Tensor的所有索引$\\text{index}_1 ... \\text{index}_N$的形状都必须是$M_1 \\times M_2 \\times ... \\times M_K$，同时输出的第$[m_1,m_2,...,m_K]$个元素是$\\text{tensor}[\\text{index}_1[m_1,m_2,...,m_K], \\text{index}_2[m_1,m_2,...,m_K], ..., \\text{index}_N[m_1,m_2,...,m_K]]$。\n",
    "\n",
    "为了便于了解，我们可以先假设$\\text{index}_i$都是一维的数组，并且他们的形状都一样，从而输出的形状也和$\\text{index}_i$一样。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7],\n",
       "        [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(12).view(3, 4)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 4, 11])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 构造相同形状的索引，行索引为t.tensor([1, 2])，列索引为t.tensor([0, 3])\n",
    "# 行索引和列索引相互对应，获取索引为a[1, 0]、a[2, 3]位置的元素\n",
    "# 输出结果的形状与索引的形状相同\n",
    "rows = t.tensor([1, 2])\n",
    "cols = t.tensor([0, 3])\n",
    "a[rows, cols]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 0,  5, 10])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 输出主对角线的元素\n",
    "a[[0, 1, 2], [0, 1, 2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0,  3],\n",
       "        [ 8, 11]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 获取四个角的元素\n",
    "idx1 = t.tensor([[0, 0], [-1, -1]])\n",
    "idx2 = t.tensor([[0, -1], [0, -1]])\n",
    "a[idx1, idx2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于整数数组索引的计算，满足下面两种情况。\n",
    "\n",
    "（1）如果$\\text{index}_i$是高维Tensor，并且形状一样，那么等价于先把它们reshape成一维的Tensor，进行索引操作后再把输出的结果重新reshape成原来形状。\n",
    "\n",
    "（2）如果$\\text{index}_i$的形状不完全相同，但是满足广播法则，那么它们将自动对齐成一样的形状，从而完成整数索引操作。索引结果的形状与广播后的索引数组的形状一样。对于不能够广播或者不能够得到相同形状的索引，无法进行整数索引操作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[7, 9],\n",
       "        [2, 6]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 高维度tensor索引\n",
    "rows = t.tensor([[1, 2], [0, 1]]) # shape：(2,2)\n",
    "cols = t.tensor([[3, 1], [2, 2]]) # shape：(2,2)\n",
    "a[rows, cols]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[7, 9],\n",
       "        [2, 6]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[rows.view(-1), cols.view(-1)].view(2,2) # 等价于先变成一维再转成高维"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 4,  8],\n",
       "        [ 7, 11],\n",
       "        [ 5,  9]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 不相同形状的index索引，满足广播法则\n",
    "# 获取索引为[1, 0]、[2, 0]、[1, 3]、[2, 3], [1, 1], [2, 1]的元素\n",
    "rows = t.tensor([1, 2])[None, :] # shape：(1,2)\n",
    "cols = t.tensor([0, 3, 1])[:, None] # shape：(3,1)\n",
    "a[rows, cols] # 广播后形状为（3,2）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意：不能先对索引数组进行组合，再进行索引操作。如果只有一个索引数组，那么该数组会被视为第一个维度上的索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 错误示范\n",
    "idx1 = [[0, 2], [1, 0]]\n",
    "idx2 = [[1, 3], [3, 1]]\n",
    "idx = t.tensor([idx1, idx2]) # 提前将索引数组进行组合\n",
    "# a[idx]\n",
    "# 如果报错，表示超出了索引范围\n",
    "# 如果没报错，但是结果不是想要的结果。这是因为只索引了第一个维度，后面的维度直接进行切片"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 基本索引和高级索引的结合\n",
    "\n",
    "如果索引中至少有一个切片对象、省略号对象或`None对象`（或者Tensor的维数多于高级索引的维数），那么索引操作可能会特别复杂。理解它的最好方法是从输入输出的形状入手。正如开头所说的，一旦确定了输出输入的形状，剩下的就呼之欲出了。\n",
    "\n",
    "根据基本索引出现的位置，高级索引和基本索引(`start:stop:step`和`None`等)一起出现的情况可以分成两种：\n",
    "\n",
    "（1）基本索引将多个高级索引划分到不同区域：例如`tensor[idx1, :, idx2]`或者`tensor[idx1, :, idx2, idx3]`。高级索引操作产生的维度出现在输出Tensor的开头，然后是子空间维数。因为所有的高级索引并不相邻，所以无法确定高级索引的维度应该替换Tensor的哪些维度，因此将高级索引的维度放在输出Tensor维度的最前面，然后补齐基本索引的维度。\n",
    "\n",
    "（2）所有的高级索引都处于相邻的维度：例如`tensor[..., idx1, idx2, :, :]`或者`tensor[:, idx2, idx3]`。来自高级索引操作的维度被插入到输出Tensor中，位置与它们在初始数组中的位置相同。\n",
    "\n",
    "上面的描述可能比较抽象，下面举例说明，注意基本索引的位置以及输出的形状。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 2, 4])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(120).view(5, 4, 3, 2)\n",
    "idx1 = t.tensor([[1, 0]]) # shape 1×2\n",
    "idx2 = t.tensor([[0, 2]]) # shape 1×2\n",
    "idx3 = t.tensor([[0, 1]]) # shape 1×2\n",
    "\n",
    "# 高级索引被基本索引:所分隔，高级索引的维度放在Tensor输出的最前面\n",
    "# 结果中：维度(1,2)来自高级索引的维度，(4)来自:切片所在的维度\n",
    "a[idx1, :, idx2, idx3].shape  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 1, 2])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 所有的高级索引相邻，直接将维度数插入到对应位置\n",
    "# 结果中：(5)来自:切片所在的维度，维度(1,2)来自高级索引的维度,\n",
    "a[:, idx1, idx2, idx3].shape "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 2, 3, 3])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 高级索引被基本索引`:`所分隔，高级索引的维度放在tensor输出的最前面\n",
    "# 输出维度中第一个3 来自于 `0:5:2`\n",
    "a[0:5:2, idx1, :, idx3].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([3, 4, 1, 2, 2])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0:5:2, :, idx3].shape # 最后一个维度默认:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([3, 1, 2, 3, 2])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 因为索引的个数少于a的维度，因此会在后面补 ...\n",
    "# 等价于 a[0:5:2, idx1, :, :]\n",
    "# 所有的高级索引相邻，直接将维度数插入到对应位置\n",
    "a[0:5:2, idx1].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 2, 1, 3, 2])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 高级索引被基本索引None所分隔，高级索引的维度放在tensor输出的最前面\n",
    "a[idx1, None, idx3].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 2, 4, 3])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 高级索引被基本索引...所分隔，高级索引的维度放在Tensor输出的最前面\n",
    "# 根据推理，可知...指的是第二第三个维度，也就是 5×4×3×2中的4和3\n",
    "a[idx1, ..., idx3].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([4, 1, 2, 2])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 因为索引的个数少于a的维度，因此会在后面补 ...\n",
    "# 等价于 a[2, :, idx3, :]\n",
    "# 所有的高级索引相邻，直接将维度数插入到对应位置\n",
    "a[2, :, idx3].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 2, 7, 1, 2, 4])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 练习：分析输出的形状和每一个维度的意义\n",
    "a = t.arange(720 * 7).reshape(7, 6, 5, 4, 3, 2)\n",
    "idx1 = t.tensor([[1, 0]]) # shape：1×2\n",
    "idx2 = t.tensor([[0, 1]]) # shape：1×2\n",
    "a[:, idx1, None, :2, ..., idx2, 0].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean Array Indexing\n",
    "\n",
    "当索引数组的类型是布尔型时，会触发这种高级索引。布尔类型的数组对象可以通过比较运算符产生，下面举例说明："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ True,  True,  True,  True],\n",
       "        [ True,  True,  True, False],\n",
       "        [False,  True, False,  True]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(12).view(3, 4)\n",
    "idx_bool = t.rand(3, 4) > 0.5\n",
    "idx_bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 0,  1,  2,  3,  4,  5,  6,  9, 11])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[idx_bool] # 返回idx_bool中为True的部分"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "布尔数组索引常用于对特定条件下的数值进行修改。例如，对一个Tensor中的所有正数进行乘2操作，最直观的方法是写一个for循环，遍历整个Tensor，对满足条件的数进行计算。我们可以使用布尔数组索引来简化运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 2, -3,  4],\n",
       "        [ 4, 18, -1],\n",
       "        [-8,  8,  2]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 利用for循环\n",
    "a = t.tensor([[1, -3, 2], [2, 9, -1], [-8, 4, 1]])\n",
    "for i in range(a.shape[0]):\n",
    "    for j in range(a.shape[1]):\n",
    "        if a[i, j] > 0:\n",
    "            a[i, j] *= 2\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 2, -3,  4],\n",
       "        [ 4, 18, -1],\n",
       "        [-8,  8,  2]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 利用布尔数组索引\n",
    "a = t.tensor([[1, -3, 2], [2, 9, -1], [-8, 4, 1]])\n",
    "a[a > 0] *= 2\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1, -3,  2],\n",
       "        [-8,  4,  1]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回Tensor中所有行和小于3的行\n",
    "a = t.tensor([[1, -3, 2], [2, 9, -1], [-8, 4, 1]])\n",
    "row_sum = a.sum(-1)\n",
    "a[row_sum < 3, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "包含布尔类型的索引的输出形状是不固定的，取决于布尔索引中有多少个True。通常来说，如果一个索引中包含了布尔型的索引，那么这个结果将等价于在相同的位置插入`obj.nonzero(as_tuple=True)`，然后使用整数数组索引的机制完成运算，即`tensor[idx1, bool_idx, idx2]`等价于`tensor[(idx1,)+bool_idx.nonzero()+(idx2,)]`。下面举例说明："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 0,  2,  4,  6,  8, 10])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 只选取偶数\n",
    "a = t.arange(12).view(3, 4)\n",
    "mask_idx = ((a % 2) == 0)\n",
    "a[mask_idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0, 0, 1, 1, 2, 2]), tensor([0, 2, 0, 2, 0, 2]))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([ 0,  2,  4,  6,  8, 10])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mask_idx 可以转化成整数型索引\n",
    "int_idx = mask_idx.nonzero(as_tuple=True)\n",
    "print(int_idx)\n",
    "a[int_idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0,  1,  2,  3],\n",
       "        [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask_idx = t.tensor([True, False, True]) # 第1, 3行\n",
    "a[mask_idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0, 1],\n",
       "        [8, 9]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 第1, 3行的前两列\n",
    "a[mask_idx, :2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1,  9],\n",
       "        [ 3, 11]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 第1, 3行的第2，4列\n",
    "col_idx = t.tensor([1, 3])[:, None] # 注意形状，广播法则\n",
    "a[mask_idx, col_idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ True, False, False],\n",
      "        [False, False,  True]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 4, 5])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(120).view(2, 3, 4, 5)\n",
    "mask_idx = t.randn(2, 3) > 0\n",
    "print(mask_idx)\n",
    "a[mask_idx].shape # shape: N×4×5，N为mask_idx中True的个数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 5, 5])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(120).view(2, 3, 4, 5)\n",
    "mask_idx = t.tensor([[False,  True, False, False],\n",
    "                     [False,  True,  True, False],\n",
    "                     [ True, False,  True, False]]) # shape 3×4 其中True的个数为5\n",
    "a[:, mask_idx].shape # shape: 2×5×5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 6, 87, 33, 40, 50])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx1 = [0, 1, 0, 0, 0] # mask_idx中True个数为5，这里idx1，idx2的长度也为5\n",
    "idx2 = [1, 2, 3, 0, 0]\n",
    "a[idx1, mask_idx, idx2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 6, 87, 33, 40, 50])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用obj.nonzero(as_tuple=True)在布尔型的索引位置进行替换\n",
    "mask2int0, mask2int1 =  mask_idx.nonzero(as_tuple=True)\n",
    "a[idx1, mask2int0, mask2int1, idx2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 小试牛刀：用高级索引实现卷积\n",
    "\n",
    "在深度学习中，最常用的操作是卷积操作。除了调用PyTorch封装好的函数，读者也可以自行编写一个函数实现卷积功能。根据卷积的定义，只需要遍历整个图像，依次获取与卷积核相乘的子块，相乘求和后就可以得到卷积的结果。为了进一步简化计算，可以采用`img2col`的思路，将整张图像提前转换成与卷积核相乘的子块，再把每个子块的维度展平，此时形状从$(C_{\\text{in}}, H_{\\text{in}}, W_{\\text{in}})$变化为：$(C_{\\text{in}} \\times K \\times  K, H_{\\text{out}}, W_{\\text{out}})$。同时，卷积核的形状可以变为$(C_{\\text{out}}, C_{\\text{in}} \\times K \\times K)$，最终通过矩阵乘法就能得到卷积计算的结果，示例如下：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Conv(img, filter, stride=1, padding=0):\n",
    "    '''\n",
    "    img: 形状为 channel_in×height×width\n",
    "    filter:形状为 channel_in×channel_out×kernel×kernel\n",
    "    '''\n",
    "    Cin, Hin, Win = img.shape\n",
    "    Cout, K = filter.shape[1], filter.shape[2]\n",
    "    # 计算卷积输出图像的参数，默认stride=1，padding=0\n",
    "    Hout = ((Hin + 2 * padding - K) / stride).long() + 1\n",
    "    Wout = ((Win + 2 * padding - K) / stride).long() + 1\n",
    "\n",
    "    # 卷积核下标的索引\n",
    "    K1 = t.arange(-(K//2), K//2+1)\n",
    "    idx11, idx12 = t.meshgrid(K1, K1)\n",
    "    # 输出Tensor下标索引\n",
    "    H = t.linspace(K//2, K//2+stride*(Hout-1), Hout).long()\n",
    "    W = t.linspace(K//2, K//2+stride*(Wout-1), Wout).long()\n",
    "    idx21, idx22 = t.meshgrid(H, W)\n",
    "    # 两种索引的组合形式\n",
    "    idx1 = idx11[:, :, None, None] + idx21[None, None, :, :]\n",
    "    idx2 = idx12[:, :, None, None] + idx22[None, None, :, :]\n",
    "\n",
    "    # 改变filter的形状，便于接下来的矩阵相乘\n",
    "    filter = filter.transpose(0,1).reshape(Cout, Cin*K*K)\n",
    "    # 输入图像经过整数数组索引后改变成适合矩阵乘法的形状\n",
    "    img = img[:, idx1, idx2].reshape(Cin*K*K, Hout*Wout)\n",
    "    # 矩阵相乘得到卷积后的结果\n",
    "    res = (filter @ img).reshape(Cout, Hout, Wout)\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[ 0.,  1.,  2.,  3.,  4.,  5.],\n",
      "         [ 6.,  7.,  8.,  9., 10., 11.],\n",
      "         [12., 13., 14., 15., 16., 17.],\n",
      "         [18., 19., 20., 21., 22., 23.],\n",
      "         [24., 25., 26., 27., 28., 29.],\n",
      "         [30., 31., 32., 33., 34., 35.]]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[[ 7.0000,  8.0000,  9.0000, 10.0000],\n",
       "         [13.0000, 14.0000, 15.0000, 16.0000],\n",
       "         [19.0000, 20.0000, 21.0000, 22.0000],\n",
       "         [25.0000, 26.0000, 27.0000, 28.0000]]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img = t.arange(36).view(1, 6, 6).float() # 初始化一个单通道图像像素矩阵\n",
    "print(img)\n",
    "K, Cout, stride = 3, 1, 1\n",
    "filter = t.ones((Cin, Cout, K, K)).float() / (Cin * K * K)\n",
    "Conv(img, filter, stride)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们只需要分析输入数据和输出数据的形状，中间变换过程可以通过整数数组索引完成。下面，我们将利用刚刚的卷积操作，模拟对一张图像的平均池化操作："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=RGB size=306x165 at 0x7F91AFD1E2B0>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch as t\n",
    "from PIL import Image\n",
    "from torchvision.transforms.functional import to_tensor, to_pil_image\n",
    "\n",
    "# 读取一张图像，模拟池化操作\n",
    "img = Image.open('./imgs/input.png')\n",
    "img_tensor = to_tensor(img)\n",
    "img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGYAAAA3CAIAAABxb6hnAAAwsElEQVR4nH27WY9l2XUmttbawxnvPMScmZEZOWfWzCoWySIpqammWlK3BRt8kNR2A91vBuwf4De/GDDQsOF2wwYMG+3ZFhoWrYFqihIHFVmsolgTa8isHCNjjrgRd75n2sPyQ2ZR1IvPwwXOvge4+3zn+9b3rbP3xZeubYggNLbs1kRTmXVZXV5eqqetcSaHRTj10Yc7j17aCr5Rm/SSC5/V3/jk3G+OJydv/el/A4fv3bjyhU5749F0PK0/v/nCH3S6vZVO3ki1CZK9+7v207fl9nvprddPZpMosI9+9p1W9iQrfPfC5YlxZ5X65u/98/ngtFNszwcPXLaz2pWmnPSWXxtuvJQefBz5O9R5/dyv/SEWT44aL7yzh7Vq8WgE7JyazWvo1jf7k2qxFjf6TVN759vhO39+5qb1f/KtaDSNTk/K8+d0szn94N3svU987zw8d6veWoL11uq584dni/65rcng6PEv3rn9/NegmOU8U+dvPZz448Pxarc79+p4bEqLzEAoLIFFREYJCMgylOXK8lJZlJ1aVNOwda5dj/XqyoXF45Pxk+FbH/6o2w+P9oM/KcW1Ky6f/Xm8++OiOr+a57/3L37/8XB6+dY3+ov+rHX9RMCZmloV5o7F4O7dn32niXjx+ZfK07tSRTvj0m7cOM1Wg8Ws8Eb5+dZy42/f/m4cNlaXVKsuPONkMC1U0GIqZuPB3Y/X4id918BffN9keyY5yMe9iV7JuVGe7aVpMs8LOpgL5z9qTl4Y7PnRgb560Y4z2jkwDz91x6d3/vqHvdX1uBk2v/KyjjvzJDx67+frfOOn9499Pl/WavH+e2J//y6/HYS2364P797bOvfcYrw/MsLFzUCHBn1lDXrHTAAeGIAJEeQrz197442vHh+cTIZjW5nG+srzL91+/8M7RaMhen7j8qWQx9evXhxX3QdF+frF1oOjS5/c/8sXvnZp98n4+3/109EovfDKZRxtX0x+4+HHd44Gf/PBh28dH+3LarHViq2v1tv97qXnZLp2SNGMwgHG97Y/fnmrVZpqdasXdC6XtU40qouwsb50/sil++mGWb00H0c/e/LdV+VF8/47ER33rmG8mPva+cTXGsu3S+FELVsU81ppalLbn/+4Xht9isUXf+2f7N59p35pJa8FF+KlfJHNzLRe+e17H8heR8wXkyePNn/zD5t2/JP/43/S1krduFCLHz/48OSs1rp1/t6D7XlZerbGlplCKwQTec8MjtkLAIXIQHJjffPTX3zy4vPPn3/9K5/cfdBb70ydDnvnBkd3W8tLo+G8XVv/6PB+kNhULD0Z1r/zkz+Nr7Qm6QuLWWP162t7j9/88Ad/VmASpf9jva4F+BtXX3vxmy92+iv2wTu1o4+2Z061LyXr15u+hqXaWumf7t6va3O0d//xw7PVYnftMnm3OHh8vzPLc06PuiIImzLtn7nm7u6AOI+vPfd4Z8S2VkuLJfMpymlADONhq6yCebbXv1Ttvh9dbZX78zfv/F+lKESDs+msGchGQN2a8g9309l0yuV8VKS3LiVL7Z37B3dm+au3bu3uHoY7hzEmlUuObbQX1sVGV5XCypAZPTMSA3kElsT1SKdKGOPw3/4P/9Xjex8/f/NqVK/9+GcfrK0vn47G73zwaZykiaJeLeie3/z+Bw9rk7kdTj6b2+vPvbb5wu/0lng5upMNT7pmMR3P74zr7x1Fnauvht1zOl23UisBLap0NhGcPTk+bq5sOIorK62QjsJQa1kVZ/d/mtijB3/7Fy+sd2rzsyv9zuxs+Cjd9KuXRrund+6//XqqbrTy8NbVpXZwMlXzU32jfKzT4OjMRCs3d210Crr/2V0a/UgF4tEwbnfCpo4751Y+vvOxGtvrG+3akl/qdrLh+P5sGorOca2+9OXfuvH8K3GtvvPgwTt//e+ef+Xldr0+N8E2bRxQjcEIX3oZsQgJWKAPED04QNuMVCdWlh3+q//8P7t5/Wqv19w73PnOd//y8OTsbDCaT6YrS/2kHi71ezZcejDI9M77Ww147h/93qOlf+G4sUL/68u1/xNG4mhyJerNh/Cb75nfPYmE8G2FTGwkMiJ6T1JQZRgQmFmQQPAohBAgwKeqqmHOk4Of/+DPt3rxWiTHh3vdF14d+aCKVjhKWovjo7f+TG1czgYHr/IRnA0zsh8PDzfPP/fZ42kVrsT9C/WDHy323ly+eN3uHK+36u1W93g61J2Vr375Kwcf/8SacWmpHsulrYs7o7K+dTNZvyZ6W0XYzgVnxV6V++uXr48X/OkBH8zJC1AKGAiQBKIg1giMDtlKxFAq0l6qMMis+Zf/7b8+GhzO5lNjgBgjJeqxOhkcfviL9zpJ3JL4H//BF7utxfK5wx+fvb970F9ufRzNxmnaWygI7MCK4wCNFIF0IIEBpGdAAECwzCQBAACQCCQLgUjADM6gWijVOtf49f9oIybHi2l+cPSzh49FwL5hajokGccrm0s13D84O8yq9dUNDGPdufGwhKzfOb91u7S01H21fX3D6sZg8R2reOD9hevPHRycfvzuB90wLc7GxWSAITdU0G50ptsPLdSDdCmr9XZHVsP5ytu/uZcXhnOLHpSUITAQIgI+nTOzBQaPsvJYVsgFyZ++89buH++djs6KqiAlbZYnOuis9C2UQUDdc92I9OutnlRqXqOzxYOW+C/m0e+WOc1r1/OGOJo0+pjqZKoXZeiXiZif/hbzU5yInp0hohCIHhgZBFalYwEWxHzqkiSxeWGKhmh32/UrkcTMMHhHHke5Pdy9s9YQEPY+mRfHk5lrb/UunMfCBUurzSAcDYTL++tp7fJvd/PTT9TWtXv3H8zF7Hyvfbh7YhZVLSs6aWP/ozvLl6404nrQHyeT3TsHBz69caQ2Fsio0aMnBZIcsQGQiADAAAiAHiyDYC88AAOTZ5nNxlGgpKAorU0W80jqXq/b7vcO9rZtmW8sdzbJv9ym1mSelSdBMu31r+6r/7nbvV5k03Lyj4e1r5bhT8rRzAc28lYg5KQQn8EGAIjPsEMERAYCBrYeSArngB0LVLnzgDEjGkYTMvlKRILAZfmJvvhK8sa3zOndyU/+96mT/vxrW5uXJwtzdLC9u/vk8rnl1uZlYThwZ41e/yQftRbVmgiWL19/59vfTlkJUtCtGZ2WviAZFZPZ6Mf/Lv0h9lrnoi+YyVasIA6dKIW2hIAe0CN/PnMAZqjAIRMxS/JKVN2mkAFAVpQr3f7RcCRRNZJ0qbt6cHScNjpQ5OVJCUut0cpGUcZimmzP3u13n6xflP7x6bW1YFB9tCs23HwDi8qphQ8cYYjMRACA8Aw4/wwyAEQABH46IVbwd18wICMTIipgic4xlSzjxppo4BwpBimifljbOOTW6RwzFy5duD47eHh8sL9/Om83a5PB23srFy5tvqpPHzb7l+anI7VyY7p7v9tOJ+3+vcPD52/eNnEyyY7H2/vd5dXJw89U2nqpFc2pVojGpLYyCWqVkID+7z9jsCiUI+l9zFlDl1f7TfyD3/xq6UsHfjRbLDJTTLON1bVuP31474Ot1fXLYfC1K/E45jZ3y4OjUuzuB5uXXolDurea+gX09vzr86NbRbB2b2ntDK8oG7BkRPyVauDg8+Nz9j2bz9OnycSEDtADE7JQaBUbA9IpJdmDLxvV8eLTt11J06BXP3elKCmttcpstlxThw8/unphpcxOqjt/WlBzWqX/4NdeGFkj4lY3CbZ/9r1Ljdrb3/ublXYrtnaw89C4bKNzbjo67sZhr708zOzyCy/cN5JufCVbuTJFCQT4OcUQEBFy4sDYruRLPVppCQVW1tYuPXj/b4+PdpZajW6S1s/H+Xh4vX5j81K2uSqOPv2gY280RkTiMAun7bgeXK9t9GA8KCrQ7Yb34t79UWMWnsuCtiWtbUYuJsRnlQB/ybVfYvUUSX5K/s/ZKD/nHiCgo0AgCu8BoJRYmHrr8tdHNus0WoChYp0wLdVDU2YbN59faovVqP2dT394+crVPGh/fGy39485Xnjv+8lNp9Ot/+BGP1B3vvudW//gduNib2CaxfZHQTYpc9O9uZJevLBuMFtpqaZyC1c5LlE85T0BMAOBqAfu8pJcSoT03oKQ7737zulJ1okv3r7Qi3i3Hviwv5GdnTSTMKHqpedumDAZDQbNdmIDbm/209Xd0/HCqdjryJuFdU0Qcax7kWkspKhEHH9OpqdEY6a/h9jntP+VEfgcWAQA+rsRAoBQRC6MziJXKZYVLytsBHkj0O1YVyXNM7PeTRLEtcs3rr/6xpSDvZ29uNnV7T6qEKwt8sUTMj/fe1I2Vri+0mos7x9Vvee/sijmCFS7fFG12/WKDkdmUbookKJyhSEGQARGBABBzEKd5sDAXFVFWeKXv/TcSue525u350/eWtb3RNA9ynvQaFX2OCgmy3GUyFlLSoYyWG35btQWjxbWZza/eL5RDxaONj+d/aP33LWyfRPLtqTCYO1zyAgR4JmDAj8zTv9LpJ6OPFUx0TPYxK8IGQDIAiFkylXS9Sp+sREu12yqIVFAQlSWpw6ds6fjiRFBUK/7ypXG398ZDBfZ2vqKdZ6V9mA6JLLRYCZ9O+7MyxlMJ6lSerkb1SJrRWaRQGibo3eF19Z7qZXxzjMTKUkQoAvAaHS9fiQX3i1f3DidnMJilkrcWpcX4stZ+yt/+bPvGLe31OZoLlKnIt0ejAJI1st2vSw/i4O89P6w7M4ar30cfnmS3CYrYu2dME8F9RQlIvylAJmB2SPSU2gIiZn5WcnAz33972jIzABAwguP2jM624pkq0aBVIHiIMLKABNmnkdGj6jlGf2wMJV3Xgb1Xk0tBpNxPp1uXbiYozJMQX3ZKWaPQT0M0k4v0WPvJxUDSwZExwx+uR0KU8lQT/NF6SwKWuTAQjGq0gsU/nRWyGGWPTh4sBo2Li61U5ulB0cc/Hw4Hd8+P5fcOD24n4fi4KS8efm1B6NsqbNcwWGgB7XkZGPj6idH57azL2tdv1L9UbfMBsUXBs0LTuDTG0ZkRAA08CuYEeqnihMCmYEZ+ZnDPktyRPRLvACgEEp4RAZBauHNzsxpYZLQ1LwgFZ2MFoOxXXjFYaQESFdmXpLU6DhKoloQ+ESdHh8WoeSkHurASpToKiKFalo6q4GtIY/gBIBDja0GrqrAgs8binS8qIon+z5nLjwykkdgF8svbaUHx++581fLZu3xPPGEYXWWjAblSS47zavXnh+OByoMvn/2gEXxxdJWsJ1xBa0v3J9Oo6RWmXDsG/kovJE+uFT734aCHmXf2A+/ViodohXMlsSvQgDgn2rTASIhAaJ/ps2nB/PTi58yFCRaL5kRpGfnxd68UljFJhY5KcXTCRSUoGACk1WlkmiBBTNpAJRGAaTNVtqWFoChBCakkDBgZM8lEFSoWVjhnMo12bagtmagPEKMvWAWwsathg9LrmzFDrQU4K28thlevtxjKRupgCycTqphxqodzsPgk5PDL69tTg/vd118pZ/ES80Te7DcrqpFlI9biqpat7jpHyZltBDJnNN4un2zNg5LS5SeiiuGZIWpfKZT/NXq/qysISAgfS5LAPjVEPJ0EPEpKUEQEROh9ACFQ/TsC+9YADgABI8KA8nUjoyEXAgQmrNs3m6kIQJ5CIOAlRpn+YJjY7y1DEAAwMgAiIz1ei1COFt4SXEcCIEwXbjpoiqVQrSdVMaSAsFKgFTOAOYzY8NaOLFV1IxzVczHw1ortdZ98O6HnQINcg80WBiHou1h60bHGeGkKLK9wJxdlg/PsuOIx4mcTU4fWtUiUQqygBIZgZ55IRICIAF83lDx58ntqcX+MnMA89+dwueVDv3Tq4UnYQAI0TFLLb0vCVECShAKoNsMleBAoyTATiwRFHnvwaOYznKX5wUoZkAUn1cLREACMZ8ay/4gNyx0KG0YUGGdJ+VN3o1EN8Wm8sJbJJA7J36yGDT6K4PRXml91FHlYhEZe7PWThfOzm1p+Czws8OBnKv285thUjs6+2RlSTy+vzcbidsvXzn87G/r5UgkS2PVaSxfHsLrY3Glop5iFzJa8ffDBD+zSnxWs54GMv6VnIu/8gnMyJ/3DN6zBxBIiMAMROg9EJIgJGcEeI3i6LSMokCgDxWyrZDYMrMKSIbeRiBCYrbWIopn3kNAKAjQVNYDggxIqdIb78iTcogAPtBCAwtvwTkJkSyiWlGYC61mfnAQkmw4PVkwV2Zn78Ahd+rRhW5yf3aysbR+djD89M7D/vUEtTh+PCFuuep4fPi42VjaXayPgqsX6p3x8NOgEQpSINATO/DK/105p19l0y+R+dwh4f/3oKdcY2ZnnuWXpy6LgtAnMdZDEUrQOs3mRacZSQ9aaCQ8mrtJ5crMkZcBEIi/F2KeNpTEhCgZEciSzGIpTFEhRQiCUVnDVWmNEtZLjyg/eHj/xoXzw9MBlMXZZDzY88tLKwZp57RYPdc5zQb1PLt6aePkaLFw5fNXlxZiuxyCGxfkwAuzszveuCJk9UorKEflekZDdEVY9x7BI5SytC6SniUzgHdokSUBPZstMvJTGcJT4gCAJ8sMDMTP6p4V7JGRWDBRhWy90SRDkuSBPFiBXogCQHkXSwht1WzFuXclelcWxJhNjVWxQQTPzrILvSABHgShYwD2iACIz5yaAAV5ICbBwjOyFTB1VYZCgxcA1qNcO7d+cDxIgPqtZqPVDiJqteqLRVZWfnW1e3pwFjUiky2iKCnz8mywF9drLpPsqkAmlpf9TO/uHS21H6RB4NKvv7m9sbp2y1CgwAtwktkIlgjCkwd0yE8jLAIj89MO3T1jGyICM2v/LHwAIwN6omeNOxIjBiDrICrrvWKnnUffYe+ByLFfFMZxrdXKS3+WG4McCdlrRLosKg/KmVogWqkY2lKw8FbkFr2Q9NSYCYDYIwMie+kYCckBAILwwrIe5wARCeDKMr7w66sKsKb16lKfvcvmIyXhwoUNIb1xi0ubvVo4z8oizwMldV7sHx+EvZ5kNzYGFXU7tQ2VVOe2BocP3WcHad747Ytf+2djWYskaOsca0CPQMzoEC2AR4vMgkF4FB4ZwPyKRth7Asme4fNUBwCM4IgBGZEFcEBOVxlMToNqFvhK9WqLeTGf5+h5pdefTyf1/go0uiUpBmykJDwDs7TZRl0vJ3JkPZKYl7gzdGeGBSoGYAIrvScrAIOSFIMksgCWQDBo9JIqUuSEAGSpvXLeZ+COBqN6HAHXwjD97N6B0gDgzl/Y2jk7Pr++ZIyJkubp9DioN3xsxtPZUr9XTmYPj3+B6vwgq87uC5tuQ7qdFwvdrZdlkWdlmOgIwKMHQmIQxnpyQICeSEgEZABC8N577wEYEHLhvbWKBDEjc2iIAEF4AgvZIjvdW0x3JtPhuVZSA+uy6ZM9v5gvDvaPjZfd/nqc6vkn7zZXNr/w1TcKp2aTTAuMBa20kpQqckUnVKUFK8DZTMqQkYkRBSAyoBDstj97/Ojuvaooh7PJcy89/8VXr4QaCCuLjkkkFOHX3rgkIj1ZTNr1hrC23eln5bzZUnGqWs125UsRLTZXOmcH80ePj3pr9bBVD0Ju1pHnp8tJlKjg/V+c2mK2pjcu3KCduT6k1/ov/PbBoNjfP7364pej2gqjBzTam8MHD3Sc1DtLDgTK0LHwDODZe+f9s3cbDgCc0wiBQPROlayURGk+ffetYm9nNeCumj/c38mJ90enm1cv64wjLaWWh2ezgqKlbuyqcpFD4ai3tnLl9nON/vlUhjWtaxHVE4oklAbmDh+PqpEny04iSZCa4PRo9Cd//OfZNBOWBaIF9gJX1+Pf/saXXrl1kZAtu7qS+DvfuOlD4RSZPKuRaLa7R6cHt1+8yJj3ep0Hjx7VG+n4+FhyPa01najmOE2kigQpP7+ypLeWwiQJlHP2ZL6/fxz1V3bL6O6o8/ETS43VL33z36tv/RYjKVkcfPbZ29/9M2P5q9/4x8sXrzkZWCDwnozzzN6D9yAkYWGPH27f/fnb1fTsbHCY1hrNTms8OY7QnqunWtgJj5RUWuo4TA4Pji9eWJ2NT5qNdFba/XHW6yWJpmxeWOOlDiwpkfZXVza3Lt7oLq0yoaYpoCpZjSo2SjOXwnnh1I++++bdD+6VpUEJghGAdRTJMBCaagFcXGn9+peeu761XtlCxtouvMsyG4dqudc5PJpbF3x6Z/fV16+xtHGMF5eW3np4eO58/2RwUmvEqyurPD4jH7Cu6WZYO5fsP/64F+qoo2ES7R8dtZd6l4JyZ3p4Nny0+5b76vIWBBcqnttZ3gzj6Wj7dPfupevXC0DtGdA74ZlBKEFIe7uHP/zut4vt7a1IvrDRPQvoyenp8YNDRsY4fu90t6yqQCulx0mCtTSw3gyKIVA5LYxQQajNdD6vIkFkKl9Nz2ZJkjBP7w93vv+Dv4hqKzeee+nai1ebrS4TO4GKgEq69/G9N3/0djYu2UoAsrZyglQQVOiNLcFCXqlJfvZw/wfXzvVfeuUG/vPfee7JYOIiWZT5xfXViqBwZa+f1puCRLXUbslCVA5anc72k0ckObflchoNZ+VJNnvx1pIEPz6ZLdXS8cmjTsc3U5H4lLg9ODCDg+lyb7l58eWy+dqeECfj5K0f/FVcq1Yv3775+m/We+fIOQ9cgBLeSWfuffKLP/63f9S0wyWt1pIYmUfGnLLMmU5OR84RySAKdSCNUqaWCiHYVnZzTSsCbyqptSc1m1bD02Gv1wlkMB1nlXUqDTyqaeHmhUMZWKO+8sbXXnnlC0m9/eTJ3js/eGv38UFeWiEiy+S9D6RHIhSClEAiqUFIpaSoaYjRoJT4D1/pGKnjXj9zprfcXVlpe1+Yai7IEhpfmo3exvaT7bVzq/NsroPIsmmHelaJv31w59L55PatS4Oj4v5Hh92Uuq0ilMOt1e7Jzjy1QcvhahpOGLPaFx7J5Md3aVzQ1s2LHHQu3H692V0V7BV6YHD5+E/+6H85fHhHctWKgpak1U7vYFiMOB4U0/FsTCJwXiEF4GwauDD0aaKiQJnKNQOQUk2nUwAQgiY5TOal9yiEIhJlUZBDqXXabDKJw5NjCWEYRlJoHQRlUZGVCMqj8CTzyklB7XqsA11ZK7UiIaxb6DAOgqCZhqli5S3+p9+6NSv58clw9erlic2EMI1aNBuPrl++lITaVWb78eOllV5aT4vS7x8MLBQXl/oVRMd5qWko/WRr67rCNBueiWoIxWEawtXLN8y4kJOT5dBPrJXqXJGqH92v/fBRFbUaKun1N2998ctfn5wc5aPjs72H7739I815TdkkoKBWaF8Sw9Qlj8aiMg2CkEgxCpJKoKhpFUaYxupscOodeKsmiyI3zhQ5urJkMhDoIC2Ns2wEYIihsc46J7XyAFIpdl6RSKIoCgPrGIi0CirjAElJBeyAKIwj46wOAgJmUkLpOJABuoAN/pd/8OL+8bi2svH2nfuyE7QvLE8XU5fna0vLk8HZ5ub5Cor+ckfq8M033282VgoYXWh37j8+qWRwflm/uHUpzxfj6X4+3bt5vt+VvFpvvvXuI2vd7c1uSy4obvHRqFUvPh5d+Jff2+eUSMWY9LLCKG/WOvXB7qN6okLpltqxEjw8XizVg1oSffRo+GBIcxNrHXX7Xcu2Vk+rypNVUlolgQDn03xUunFmUMfgzUq7JpyzRswzXzlvoTRsHSpEwZ5IKOu8BS2JFApJIIlYeRQQqUCRioPAWXYkgyDwCEIKzyxAOpQWUAvS6CyTjJMIxRQFvfbqi70LawdZ9p3v/9XKaqu9uVzF1V5+dv+jw41z+XQ6PX9+3TmWFj4dHK+cW57vPLm18vzhePj9937xlV97qdWAJZVdDBclj7ory4O9qcv1XpktLZ91umTLtFWXX7nR+b/fvB+vryZ6VB2f6biF3eU0Xh7OjpXyw8k0RFXvqwfzcnE877SWXlytvfP+trd+NnKz2fiYfW9p1VGI4EyVx4GK43A+NL6qhPVlWe3O8oBMHGIQUBIyCgcMVeG1lkqLNE2sNfvH80Zz42zkgOK8yhhQsBQoHJg4ptLmBoOqqpAR2AE7FSXSe+nZCpkJhcZLrCdr1y6NSy7R/79/8Zdf/I2vOWO9wf0nZ+32aiW8UNPheDqeHly81jo62G7p1fULF++899FLa+vv3r3bvbb1/IvXLi83B3ce+6g+49rpqHp/z7oiqk14Sdd4rEqY9xqC6ewr19xo3nnz8bjQ5yruHR9PT08/lN6BJqlFq5YO54tusr53vG0NeCrsWR6lQVGZRTZH4aTA2eLEeC2FsmU1HfpAayHrEj2wQW/Ksugut6pyJmVkXRFIWW8kJyf7vaXVo+MDKrIkiVeWEuCJjzMhsbUaHx9ZATVTTIIwmB8frq2vHp1sJ7WGYa4sV9ZWhULH9aRhLZXOqqQuXTM5OxpBVHv3g4/a/c6HH/wikDKU8fgkP9geTqaTejOWUnZaq2fHbmP15Z9/+OG5k0UbKQtcfjCe7Z5M89PD8vBCK364fbxjxc5+/pf3s5Vup5ZT2o7WUtmMm64ctlK40eLwjfYcdz8bj6d5Xg/dpUvd7UfHs0IuCjo+OQkUTj54vMgyQpkUuTHO2jwIZJRo51wcB0VlrUEtZZVZ8CRAFfm4rEwYROCNEmiqhdaiqkprTVHkxljC8PDgbLGoysJ5J73xWviAx3XJ11fOrUhC4WbFPG3C4WCsrbmx0vAiXxg3r3xlyVZV6R1Y7nRaJ2dnqqrk7ujsdL6YzSfTedbotK9tbY1Phw/vPkzi5OLmpcHBfmO1YUqWsnXvw/3P+DS6oF/qrrabwUgXreZSmdkpBq0May1R3+jX43Q2f9QUi6Co6kGblXJ4NqlkqIKydGxtK83+4Rs9/snprWZy+4VNkbjXXur/P3/20cGAVZigcPOFc04zc1UtiKjZqLfb9ZOT483NC0jwySd3ygrD/ookbHYa49E4m0+QhIykjoXWQVllZemY2XuXJMnZYCpQk8A46TK7s0GhQCcxCOCtzcuDo+PxdJZX0/ULPeOGW5eWf/7OvYcTsbzRSdspGxNQEosi6Hf3Dk4KlfcSr/wZfuv3LzUbyw/v7SVJs9/vpvXG2+/87PZztw8OD8NACaT9nd1bt68en+zpgJutdHxagZ1+c219bbAQQAO/WL12kWsy7ovTyWfN1Cvq3Lkf79091H584cZ6WgyCJFWR7PaCKMiOfbEzNYpbCYSH5mQsp/3Gyv7J6r/6798Mkr7jUvrQOQfgnXMkEIGEEMzeeRMEOs8L5ymJQlPmjUbNOxvGyWw2L4rKOa9V6IFJCkGSSExnc2BP6DudznB0GoZaKVmLa85N6zXZazdPT4bDWdnuN4wdnVtbARduP56WNnY46vbiTmfp+GC82dcUth/vj5yrrm+tsJnKerh6feulRnxeB+rx9mf9pe5vfPlLk6PTLkoHgkTywtYXT7fvtwJ3rlVrNaOjTGEoxHisDuaN2tKococf78yE612Me2tiPhxmFc3PTDYx6VLrdDiKGwlGwdSMIi+BbEeFuwqGn52iisvlvNGKBzsnK1Hj1ed77z/IAtMpacIAgmSVl+gBSFpnhRBBqMaTydJSUysAFicndrao4qi2yLO8zKI4stZEsei0O6eno6IwxlZhJL0tujWdNLmwsLqyOjgaC5x3+u3B4JSkX9io9PpsJOdzPNjfE4IQwnmVs6gqsKGCqxtpOd6LQtOv29HE7Tw5cSHLrc3rr738FfeiuPfgs8tXrv307Z9cv3Dp5saNbrf3w5/97N6jHeuzSVah88f3TjCMbzfWR8fDC0tLWaz2onQidKSgIQpVQDbWcffa7iB/78FgOiNfk1c6tVkxSjrpUqcDYpKbSqNtRsHJwQQzt4l1qnzckIndhesXH9x5OHFDy14rbYwJw6hYFNYa58B7RsIg0EoKWxZIFISJteL0bOohQ4QgpDipVVVpqoIIiAQDMFoA6Vz98HCiw3g2mvmsSns18PLsLBuc7s/mBYNI04TAtZrR1sX1e/e2J4VRaZIXvqqozPPNK30kKUOjJT9+vEuC5D/9g//wr//qby5sXg1VfTbPf/e3f382Gl1Y3nj06MmXvvrNF75QIbvv/ODbJ9sfp6WKIT7Z3z5/bnV4bO6fZnfnFQVJcjS5tRyJKB6L2BTSYO3tJx+knd7F1rkgqoW+nJ2OufLdZVUZb02+VG/l1y8NPy1OFnVVr69Wi2592hxNpB+fOhl7DAKZF9N2M57OJmVpBEnvJRJJJU5OpmglYJnWG2WZlSZHFtYaQcY54R2MRnPvuMidDuOiKIxFpXRhJEPZiWVS94+3j4TUzosgTEThdJRIhQqpWw9bAbZCEK3I6nBeLCbTopxm40VVS6M4iFMdPHd5QzmgnUcHr7/2eq2WLveXlnurNvfP3XrhbDJDqZ0BRaLZTIFdu90PG52jRfVxxH+yv/NeVZbLq1Ol5mE0CeJTTLen+o++d/fffPvnR4v52o2NTFe789P7J8eFFVq38gnmUy3kytSvfXI3//Qov3uYHz70b384+sl9PxW9W5cP/uv/ZO2ba43K+sp5IByOh61O49z5tVo9ZfbMyJ6cJW+lNVAUxlSWPZel8x6r0he5WSwKBDmdZqbixbzIsooE5m6Smxlg2WqIL762yRCdnS2sE0gaUAopESnPyiJzeWajILp+fU2rcjzeF6ICLg+P00ePcDZtPrg3e/edJ58+mMj9nZPP7t5bWu01mp179x5LAOkLqQNTzSenGbN7/OCoJ8WCxBRs88rq6c7uUTHOFZ+L1a31rXGR7c7Hb+5Nh5PZqLK9lf6b7+/NvFvubBwcTrGmxpXG7UU7bkzuj1rn+z5IzYInFrWdJIdqrduGBvzR3zz8+sWoEdIXby59b3fuGZGE0kgCtBZxEgqhF/NFWZrlpe58NK8sT6cTz+gdSQnWGuuMmedBEJyejqIoBdbTRUZCF3mWErMhU6q9/Xx4dN/aiDHIMpOXo9JU1vl+p1u4YP+keLL3ANHpo8WsdAqSKxtXIBv+1TsH3lfzxVk2rwLRONxf4E9/9D2tEX3+3vsf/Ov/7t9861v//i8+fPcLr738+MG9m1e3kHhn98HFfvjX3/sB1vtHlbuZtheSHjx6UhNBlmc3b10SIvbY/JO/+IEnJsJQh7VmcvXK1vBoEKvw0IwiD+eWlu89fOBDDb5oN5JTcHZntCRr05WktdTPC4lnGfF8EkzH03YYBsZWUpKzZj5Z5IuSSOVZrrRkNoRMKPK8BEZidJ6tM0SsFJEgQQJAMkvDUFVlFAeR1J4Fey+8GR/siHoHkZBEXpSkNBEiMgJIEpWxSRohsfXgymy9WzOTwanXQmAUaG8hDutZmcmv/tbvRAQRwT/7p394vH+Y1qKj091m/eWrW7XzG+xctrEerbXttctvfOd7D5smDf2shqHs105Geb3bGY2Gax0AU379uVVWYW6qs+lpSQvnR+jPMIeVmlRgY3F4eR1AAgHaiLvhchF0pFCBcInGbgS+Xcu5RRWcSloI8oAyCEipeF2lKJ5uGiUBJIQnSczSs0IUiEiKBCglSCARSBk6x2GcAAnP+HTlChGe9kzeO+OD0nDlhHFyOiu9NeQtuAq9AWeYSwcFewfeRYEmhCb7OAjrYVQLokhJqQkvXFi7vrn68vULX371uZ0nj994/aUnj+7FSTAcHwO6eiNWcqxwwFZv71XjymnrIwrRqMOj8WA0lTrwtqonoSfjpIeAC+ce7GbWBb2aXGmKqORGqrQ0cRo4QYUQB1V977QV4rJKpNVlSBAqOZ5Oh/PqZDy/m0skAgTH7Nk7oR0AgGfwRCCFUjKWKlBKB0Gkg1BKRyQQhZIBABF7dj6ME0DhAKQOWWpECEOllEACAR2PqmA5rTizgJVFZ8EZCU4LJHLG5d5ZSRiHASKA5yQMEqViKRtxnEghN9eWhS1aiSxmg3OrreHZ2XhWHI8Xw2kOUkQzVpTOZ2f7+4eLglg59DnkHEOIXgLFSRAFkWOfpQkZUVFA0qZLnd50LqMIPWQ6jkRAIEyBmFk7g/pu0TmlSxo3AL2lPHLMeTFfpONFWQrUZoTI1lYS2bOrhAzDEJCLIpOSED3ilILQFaIqcytlEqZChUlSi2RKpHWsDFvvwXhGQAEBlqS0FBVq1EJgrTCFq9CLonREumBe5ItIiaLMDHgAR8+WTsCCdc7GQYCGlSKNoNCXlZEvPX9zPDgAFQ9msBhkaSsaZxGQ8ElrPJtVU48s9o7YmBVAKbEgX2klKy+V0qQCh06BlSJdOLBghFVlITKKbRzPQCGIUgjlGNmX1pcgJq5xRsvHrh1Qnyu0xNoDuKKCrNAut0z6RCshTeFsoYkVSlM5paX3C3IIXIKbkZOejQ7Z+7wAjprSlXMb2jhOfElxHMHTl2tSK6HRsiASAtk4X7qZzCmMwLESTOQx90moyVsVhchGiICBBaFAEAhMQgAmgrQpYq38IpeBlssrvWuXN2tJYzDOhqbIFyIvsTJ5URTZYiEEMRelK40jZs92rFytYtSIJAk8UBAoEQsW0urKciQCpmyubE6ignpZxZEkRQJZVKhKCBZVbeIClhEJBRRaloVn8Lmn0KLxCNDrzE1BbMEVjN5WHokssA49IEgC8hZsnigXoKmKGSr2SEKR8XlhbM0ncgZZVqgwUlFMQVDYEpG1Vkigtar5qJy6GATkwAAzEAYImKyvJCrnGVCgQCnImEoJTaG27D1hVro4UN4KGdRahTch+Xk1mxST3ITT0ZgZvPfOKVM5KcNqofJyFiUxcs1r7zCsKAEvBFKTEnDeC1cYF0T1yrDjGPIgohQUuNhOdYOE8l44Fp5llYDPrKbY6pqT7MkDAAgpgYUoUvDlvBTggTwSegYZh5U1QoAHIVA7VwmxAMGGvQxD0EJ5X1j2hQwEBOCcqDgQcaQRvfDlYjQVMnYOSzJBSPk8CyNpisqRsQ4rVwALV1ZCCEHgnFWSCIxSwlhDBBgod+aUiiiMhKZQKiaUsZSSsZhMqtkMynJeFbYqAaAoyrIqgbksCwayhgAUs4fSMz7d82HJs7VAEHgIWDhPiwr83KYZa2cDwoCQayBBCGutUEIQ5xWzU9YBEjgvPCI4AGbrXblAQlLYYLRP18aZPZLV5D2XUkjvfRDEVW4EURwE1hhXFiIoiUhJwTYr8wJFzs6TIPac5ZmSAUmbxI0wCIpiFoRYFTkxOu+9YWO89SSJvKsq40xZshJlPmu1WtaWYajnk2kaaySVZWNbcqRTpaQcHuwLcAIZyzLwPk6iGdv5bG7LHKwjKQGIvdc6yhc2DCPBXpB2hRPSM3hLEISJqZCBBRSMTos6xbooCUizp3JhozhQIgD21lgiIahiWDgWzIoZJKEzJVsj2CAwgC/LnAiCUAF49EahZXSuqpSITFE4zp0B5JKAAHyWlWm9oXXg2YZKClt4a0xpa7VaqBtKB3nuCLytCm+rqvDtVns4meswYE3OGyJk9s7ZbDYNtBKIzXpdIFvv0Ttin2ezKsuWu/1QsTUFWJbellk2bdSSqlwwi9OTSZHnABBKcsgOnNZQGlZCMAhmLKpSECgZWg+mtGGUlJVzYIUkpJg8i8rZao7GoIQkbeUk56Vx3pEUKgiFQAWVc3MichBIIkVVmc2IQQqHwFVpES0JEkIDsC2d8c75sl6vO0NKC5KcLWYMpQpUp5ZmQ2tttVhUATlrTaSkRPCSqrIwlQnCSMg4X8yTJGk169bmviobSTwrqrJ0VVGV1nvvvTOBFBJ9sZjPy0JKQQKyqQtCrQNVr9W99YxoXBUkoZxlE1vlflpllTkYjEOdpHEopTTGTKc5E1tvrPNChd6zNUYG3jjjWYVBXJVYlaEKUQdZ5X2etY2NQCUVgQ+Vh2hcsgi8R1S6ZizOCid8CEBKRBXHWjaAHflxJBPv+OmebBV6YyodSHr6pyLtrSu1CkvnnfPkFOehIFLKVuVsQbMkDirviyKTgQC21gIDVsYEWhtTeWYiV0tb2WIGUEaxHA/PHBPo2JWOgBQhChJBCMzsTaueFAskQudtGEd5mYEP59Mi53IhXL+bTueFLOezwrhcY2ldt9vJJrN8XrQ7nXqtkeUz40GpEL0BYERiKVNVVoCVtSQFoT7LBjUOW5LDwM3LGfuoKA2JYJHnpLzULrNUE0pZU2WOSTnH06ygKChtoQOpBDA4W1TWsxASGK1hCSxtaV3uERxSURSiojStB5Es8yKJqLQAHNYitNXetIRmuy+j0NnMmblZ5ImO4lpd62A6nrHHXq/rXBlFoijmWqdhoOdF6V0pibg0zJiVBXoHzgoAN5t6X3o2zrkFyDRplGbqpex2WojA5ARJmejg+OSIYh9EoffeVFU9rQdaHR4dOu88U5EbwUxPN/pJvcjmUsWB1t4WgfBOWSTHxoMoJemKK5NXQlliUCSlcCWpylS+zKOoDqgm+TxJm9PSABL7nMF7XyhFbJ1QlOUFeJJoqmLuuVRRAKSSWDvLktA7K9AieSQjKWSXeTMDFy5mszBKy7KKJC71uwFqJnLOK6UAaDqdIrJnq5Qsi7JYLEQULfK5UpFC9ETEIBCRKNbamiKoRUSB0no+K01polCFAXmb1eqxMaWD6v8D5Tr9jESAsyAAAAAASUVORK5CYII=",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=102x55 at 0x7F91A49F1048>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img = t.tensor(np.array(img)).float()\n",
    "# 将img的形状从h×w×c转化为c×h×w\n",
    "img = img.transpose(0, 2).transpose(1, 2)\n",
    "Cout, K, Cin=3, 3, 3\n",
    "filter_pool = t.zeros(Cin, Cout, K, K)\n",
    "# 初始化卷积核\n",
    "filter_pool[t.arange(Cin), t.arange(Cin),:,:] = 1./K/K\n",
    "# 利用卷积去模拟池化，将步长设置为卷积核的大小即可\n",
    "out = Conv(img, filter_pool, stride=K)\n",
    "# 将输出结果转换为h×w×c的形状，用于显示\n",
    "out = out.transpose(1, 0).transpose(1, 2).long()\n",
    "Image.fromarray(np.array(out, dtype=np.uint8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看出，经过池化操作的图像，它的长宽都变成了原来的三分之一。\n",
    "\n",
    "在本小节中，我们介绍了一些特殊的索引操作：整数数组索引与布尔数组索引，灵活的运用这些索引操作可以有效地完成数据的变形与转换。在小试牛刀中我们介绍了一种运用向量化思想实现卷积的方法，读者应当逐渐体会向量化计算的精妙之处。\n",
    "\n",
    "### 6.3.4 einsum / einops\n",
    "\n",
    "下面我们将介绍爱因斯坦操作：`einsum`和`einops`。爱因斯坦操作广泛地用于向量、矩阵和张量的运算。灵活运用爱因斯坦操作可以用非常简单的方式来表示较为复杂的多维Tensor之间的运算。\n",
    "\n",
    "#### einsum\n",
    "\n",
    "在数学界中，有一个由爱因斯坦提出来的求和约定，该约定能够有效处理坐标方程。爱因斯坦求和（einsum）就是基于这个法则，省略求和符号和默认成对出现的下标，从而完成对向量、矩阵和张量的运算，下面将举例说明：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0, 1, 2],\n",
      "        [3, 4, 5]])\n",
      "tensor([[0, 3],\n",
      "        [1, 4],\n",
      "        [2, 5]])\n"
     ]
    }
   ],
   "source": [
    "# 转置操作\n",
    "import torch as t\n",
    "a = t.arange(6).view(2, 3)\n",
    "b = t.einsum('ij->ji', a) # 直接交换两个维度\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(630)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 求和操作\n",
    "a = t.arange(36).view(3, 4, 3)\n",
    "b = t.einsum('ijk->', a) # 所有元素求和\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[2640, 2838],\n",
       "        [2772, 2982],\n",
       "        [2904, 3126]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.arange(36).view(3, 4, 3)\n",
    "b = t.arange(24).view(4, 3, 2)\n",
    "c = t.einsum('ijk,jim->km', a, b)\n",
    "# 输入a是三维张量，下标是i、j和k\n",
    "# 输入b是三维张量，下标是j、i和m\n",
    "# 输出c是二维张量，下标是k和m\n",
    "# 操作：a和b中相同的下标i和j是求和下标，结果保留了k和m\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0,  1,  4],\n",
       "        [ 0,  4, 10]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 多个张量之间的混合运算\n",
    "a = t.arange(6).view(2, 3)\n",
    "b = t.arange(3)\n",
    "# 矩阵对应维度相乘，b进行了广播\n",
    "t.einsum('ij,j->ij', a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(55)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 直观表达矩阵的内积和外积\n",
    "a = t.arange(6).view(2, 3)\n",
    "b = t.arange(6).view(3, 2)\n",
    "t.einsum('ij,ij->', a, a) # 内积，结果是一个数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[10, 13],\n",
       "        [28, 40]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.einsum('ik,kj->ij', a, b) # 外积，矩阵乘法的结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### einops\n",
    "\n",
    "除了上面介绍的爱因斯坦求和之外，其他的爱因斯坦操作封装在`einops`中，它支持NumPy、PyTorch、Chainer、TensorFlow等多种框架的数据格式。在爱因斯坦操作中，多次转置操作不再使用`tensor_x.transpose(1, 2).transpose(2, 3)`，而是用更直观的方式：`rearrange(tensor_x, 'b c h w -> b h w c')`代替。\n",
    "\n",
    "`einops`有很多复杂的操作，这里我们仅讲解最常见、直观的用法，并分析如何在深度学习框架中高效使用`einops`操作。有关`einops`更详细的内容示例和底层实现可以参考einops的说明文档。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([16, 64, 64, 3])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from einops import rearrange, reduce\n",
    "a = t.rand(16, 3, 64, 64) # batch × channel × height × width\n",
    "# 转置操作\n",
    "rearrange(a, 'b c h w -> b h w c').shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([16, 12288])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 融合部分维度\n",
    "y = rearrange(a, 'b c h w -> b (h w c)') # flatten\n",
    "y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transformer最初起源于NLP领域，在机器翻译等场景下取得了不错的效果。近年来，不少研究者也尝试将Transformer应用于计算机视觉领域。爱因斯坦操作由于其便捷、直观的特点，在视觉Transformer中得到了广泛的应用，下面我们以Vision Transformer（ViT）[^1]为例进行说明。假设输入是256×256的彩色图像，现在需要将其划分成8×8=64个块，每个块有32×32×3=3072个像素，使用爱因斯坦操作实现如下：\n",
    "\n",
    "[^1]:\n",
    "@article{dosovitskiy2020image,\n",
    "  title={An image is worth 16x16 words: Transformers for image recognition at scale},\n",
    "  author={DOSOVITSKIY A, BEYER L, KOLESNIKOV A, et al.},\n",
    "  booktitle={International Conference on Learning Representations},\n",
    "  year={2021},\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 64, 3072])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img = t.randn(1, 3, 256, 256)\n",
    "x = rearrange(img, 'b c (h p1) (w p2) -> b (p1 p2) (h w c)', p1=8, p2=8)\n",
    "x.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除了`rearrange`以外，常见的`einops`操作还有`reduce`，它常用于求和、求均值等操作，同时也用于搭建卷积神经网络中的池化层，下面举例说明："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([16, 3])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 对空间像素求和\n",
    "y = reduce(a, 'b c h w -> b c', reduction='sum')\n",
    "y.shape # 对h和w维度求和"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([16, 3, 32, 32])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 池化操作\n",
    "max_pooling = reduce(a, 'b c (h h0) (w w0) -> b c h w', reduction='max', h0=2, w0=2)\n",
    "max_pooling.shape # 最大池化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([16, 3])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "global_avg_pooling = reduce(a, 'b c h w -> b c', reduction='mean')\n",
    "global_avg_pooling.shape # 全局平局池化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 通道归一化，将求取均值的维度结果设为1，运算时即可广播\n",
    "# 对每张图像进行通道归一化\n",
    "y1 = a - reduce(a, 'b c h w -> b c 1 1', 'mean')\n",
    "# 对整个batch的图像进行通道归一化\n",
    "y2 = a - reduce(a, 'b c h w -> 1 c 1 1', 'mean')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 下面两种操作都可以打乱一个通道进行shuffle\n",
    "tensor = t.randn(2, 16, 32, 32)\n",
    "y1 = rearrange(tensor, 'b (c1 c2 c) h w -> b (c2 c1 c) h w', c1=2, c2=4)\n",
    "y2 = rearrange(tensor, 'b (c0 c) h w -> b (c c0) h w', c0=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "所有的`einops`操作都支持反向传播，可以有效地将它们嵌入到深度学习模型框架中。当我们使用`view`将卷积部分和全连接部分串联起来时，`view`只能写在forward中，而通过`einops`操作我们可以直接将维度转换的部分嵌入到网络中，从而在一个`Sequential`中构建整个网络。更多示例请读者参考einops的官方教程。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([16, 3, 64, 64])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x0 = t.rand(16, 3, 64, 64)\n",
    "x0.requires_grad = True\n",
    "x1 = reduce(x0, 'b c h w -> b c', reduction='max')\n",
    "x2 = rearrange(x1, 'b c -> c b')\n",
    "x3 = reduce(x2, 'c b -> ', reduction='sum')\n",
    "\n",
    "x3.backward()\n",
    "x0.grad.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.4 小试牛刀：使用向量化思想解决实际问题\n",
    "\n",
    "本节将实际应用向量化思想解决几个深度学习中的经典问题，读者可以在这些示例中进一步领悟向量化思想和高级索引思想。\n",
    "\n",
    "### 6.4.1 Box_IoU\n",
    "\n",
    "`Box_IoU`是目标检测任务中最基本的评价指标。简单来说，`Box_IoU`就是模型预测的检测结果框与原始标记框（Ground Truth）之间的交并比，如图6.4所示。\n",
    "\n",
    "![图6-4  交并比](imgs/IoU.PNG)\n",
    "\n",
    "目标检测中的`IoU`评价指标可以用公式(6.3)进行计算。\n",
    "\n",
    "$$\\text{IoU}=\\frac{\\text{Regression} \\cap \\text{GroundTruth}}{\\text{Regression} \\cup \\text{GroundTruth}}\\tag{6.3}$$\n",
    "\n",
    "其中，分子部分表示两个框的交集，分母部分表示两个框的并集（这里暂时没有考虑两个框无交集的情况），二者的比值即为`IoU`的结果。\n",
    "\n",
    "在实际问题中，我们往往通过计算`IoU`的值来判断回归框的效果。最直观的计算方法就是遍历每个Regression框与Ground Truth框，以此计算IoU，实现代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.09090909090909091"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 框的左上和右下的坐标，默认两个框的交集存在\n",
    "Lx1, Ly1, Rx1, Ry1 = 0, 3, 3, 1 # 回归框\n",
    "Lx2, Ly2, Rx2, Ry2 = 2, 2, 5, 0 # Ground Truth\n",
    "\n",
    "area_reg = abs(Lx1 - Rx1) * abs(Ly1 - Ry1) # 回归框的面积\n",
    "area_gt = abs(Lx2 - Rx2) * abs(Ly2 - Ry2) # Ground Truth的面积\n",
    "\n",
    "inter = min(\n",
    "    abs(Lx1 - Rx2) * abs(Ly1 - Ry2),\n",
    "    abs(Lx2 - Rx1) * abs(Ly2 - Ry1)\n",
    ") # 计算两个框交集的面积\n",
    "\n",
    "IoU = inter / (area_reg + area_gt - inter) # 获取IoU的值\n",
    "IoU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在实际的检测问题中，对同一个Ground Truth会回归得到一组框，依次计算每一个框与Ground Truth之间的`IoU`值稍显麻烦。因此，我们可以采用向量化的思想，同时计算一组返回框的`IoU`，实现代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.0909, 0.1667, 0.7500, 0.3333])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 默认所有的Regression框都和Ground Truth有交集\n",
    "# 模拟四个候选框和一个GT框\n",
    "Reg = t.tensor([[0, 3, 3, 1], [1, 4, 3, 0], [1, 2, 5, 0], [-1, 2, 4, 0]])\n",
    "GT = t.tensor([2, 2, 5, 0])\n",
    "\n",
    "# 通过广播法则计算交集框的边长\n",
    "dist = (Reg - GT.reshape(1, 4)[:, [2, 3, 0, 1]]).abs()\n",
    "# 计算这一组候选框分别与GT框的交集面积\n",
    "inter = t.min(dist[:, [0, 2]] * dist[:, [1, 3]], dim=1)[0]\n",
    "\n",
    "# 计算每个返回框的面积\n",
    "Reg_edge = (Reg[:, [0, 1]] - Reg[:, [2, 3]]).abs()\n",
    "area_reg = Reg_edge[:, 0] * Reg_edge[:, 1]\n",
    "\n",
    "# 计算Ground Truth框的面积\n",
    "area_gt = (GT[0] - GT[2]).abs() * (GT[1] - GT[3]).abs()\n",
    "\n",
    "# 计算这一组返回框与Ground Truth框之间的IoU值\n",
    "IoU = inter.float() / (area_reg + area_gt - inter)\n",
    "IoU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.4.2 RoI Align\n",
    "\n",
    "使用过Faster RCNN和Mask RCNN的读者对于RoI Pooling和RoI Align肯定十分熟悉。这两种算法的目的均为：对于具有不同特征大小的输入区域，都可以得到具有相同大小的输出特征。\n",
    "\n",
    "具体来说，RoI Pooling的目的是将不同size的RoI（Region of Interest）区域映射到固定大小的feature map上进行池化操作，以便后续进行分类和回归。但是在映射到特征图和进行池化操作时，由于feature map的大小已经固定，因此RoI Pooling中需要进行两次量化。\n",
    "\n",
    "（1）将RoI对应特征图与原始特征图的网格单元对齐，也就是将候选框边界量化为整数点坐标值。\n",
    "\n",
    "（2）将第一步得到的量化RoI特征进一步细化为量化的空间单元（bin），也就是对每一个单元的边界进行量化。\n",
    "\n",
    "然而，经过两次量化后，候选框已经与最开始的回归位置有一定偏差，也就是不匹配问题（misalignment），这一问题对于小目标来说非常致命。相比之下，RoI Align算法全程保持浮点数，通过双线性插值算法计算最后的池化结果，解决了RoI Pooling中的不匹配问题。\n",
    "\n",
    "RoI Align算法的流程如下。\n",
    "\n",
    "（1）遍历每个候选区域，将网格单元平均划分为$H \\times W$个子网格区域（注意，与RoI Pooing不同，无需进行量化操作）。\n",
    "\n",
    "（2）对每个区域选择4个采样点，进一步划分为4个子区域，取得每个子区域的中点。\n",
    "\n",
    "（3）使用双线性插值算法计算这4个中点的像素值大小。\n",
    "\n",
    "（4）通过池化操作对每个子区域进行聚合，从而得到最终的feature map。\n",
    "\n",
    "下面我们将用向量化思想实现RoI Align算法。首先，我们从形状上分析一下这个问题的输入和输出。假设经过卷积生成的feature map的形状是$C \\times H \\times W$，对应的BBoxes的形状是$N \\times 4$，其中$N$代表BBox的个数，$4$是左上和右下的坐标值；目标生成的池化结果是$C \\times N \\times n \\times n$。显然，我们需要在左上和右下的坐标值的基础上构造出$n \\times n$的结果，然后对feature map进行整数数组索引，从而得到一个$C \\times N \\times n \\times n$的结果，最后相乘便完成了RoI Align操作。在流程的第（3）步中用到了双线性插值的操作，因此我们需要在计算中扩展一个用来计算双线性插值的维度，最后消去这个维度即可。双线性插值算法的原理如图6-5所示。\n",
    "\n",
    "![图6-5  双线性插值算法](imgs/BiLinear.png)\n",
    "\n",
    "双线性插值算法主要根据周围四个坐标点的坐标和权重，得到点$P$的插值结果。首先，我们根据点$A,B,C,D$计算出点$M$和点$N$坐标与权重，然后根据点$M$和点$N$就可以得到最终的插值结果，具体的计算方法如式(6.4)所示。\n",
    "\n",
    "$$\\begin{array}{l}\n",
    "F(M)=\\frac{x-x_{1}}{x_{2}-x_{1}} F(A)+\\frac{x_{2}-x}{x_{2}-x_{1}} F(B) \\\\\n",
    "F(N)=\\frac{x-x_{1}}{x_{2}-x_{1}} F(C)+\\frac{x_{2}-x}{x_{2}-x_{1}} F(D) \\\\\n",
    "F(P)=\\frac{y-y_{2}}{y_{1}-y_{2}} F(N)+\\frac{y_{1}-y}{y_{1}-y_{2}} F(M)\n",
    "\\end{array}\\tag{6.4}$$\n",
    "\n",
    "其中，$F(·)$计算权重。由于$A,B,C,D$均为相邻像素的中间位置坐标，所以有$x_{2}-x_{1}=1$，$y_{1}-y_{2}=1$，因此式(6.4)可以转化为权重的形式，如式(6.5)所示。\n",
    "\n",
    "$$\\begin{aligned}F(P) &=\\left(y_{1}-y\\right)\\left(x-x_{1}\\right) F(A)+\\left(y_{1}-y\\right)\\left(x_{2}-x\\right) F(B) \\\\ &+\\left(y-y_{2}\\right)\\left(x-x_{1}\\right) F(C)+\\left(y-y_{2}\\right)\\left(x_{2}-x\\right) F(D)\\end{aligned}\\tag{6.5}$$\n",
    "\n",
    "下面我们通过高级索引操作实现RoI Align算法：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 1, 7, 7])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def RoIAlign(BBoxes, feature_map, n):\n",
    "    N = BBoxes.shape[0] # BBox的个数\n",
    "    C = feature_map.shape[0]\n",
    "    BBoxes = BBoxes.float()\n",
    "    feature_map = feature_map.float()\n",
    "    # 获取BBox边上等分点的坐标\n",
    "    Xs = BBoxes[:,[0]] + t.arange(n+1).float() / n * (BBoxes[:,[2]] - BBoxes[:,[0]])\n",
    "    Ys = BBoxes[:,[1]] + t.arange(n+1).float() / n * (BBoxes[:,[3]] - BBoxes[:,[1]])\n",
    "\n",
    "    bins = t.linspace(0, n*n-1, n*n)\n",
    "    idx_x, idx_y = (bins // n).long(), (bins % n).long()\n",
    "\n",
    "    # 获取每个进行pooling的bin的中心的坐标\n",
    "    x = Xs[:, idx_x] + (Xs[:, [1]] - Xs[:, [0]]) / 2\n",
    "    y = Ys[:, idx_y] + (Ys[:, [1]] - Ys[:, [0]]) / 2\n",
    "    x_floor = x.floor().long().unsqueeze(-1)\n",
    "    y_floor = y.floor().long().unsqueeze(-1)\n",
    "\n",
    "    # 获取最近四个点的相对坐标，左上(0,0)，左下(1,0)，右下(1,1)，右上(0,1)\n",
    "    corner_x = t.tensor([0, 1, 1, 0])\n",
    "    corner_y = t.tensor([0, 0, 1, 1])\n",
    "    idx_feature_x, idx_feature_y = x_floor + corner_x, y_floor + corner_y\n",
    "    # 获取feature map中的实际值\n",
    "    points = feature_map[:, idx_feature_x, idx_feature_y]\n",
    "\n",
    "    # 利用双线性插值法计算权重ratio\n",
    "    ratio_x = (x - x.floor()).unsqueeze(-1)\n",
    "    ratio_y = (y - y.floor()).unsqueeze(-1)\n",
    "    index1 = corner_x[None, None, :].float()\n",
    "    index2 = corner_y[None, None, :].float()\n",
    "    ratio = t.abs(index1-ratio_x) * t.abs(index2-ratio_y)\n",
    "\n",
    "    # 计算最终pooling的结果\n",
    "    res = t.einsum('cnkp, nkp->cnkp', points, ratio)\n",
    "    roialign = t.einsum('cnkp->nck', res).reshape(N, C, n, n)\n",
    "    return roialign\n",
    "\n",
    "# pooling后的大小为n*n\n",
    "BBoxes = t.tensor([[50, 40, 100, 120], [30, 40, 90, 100]])\n",
    "feature_map = t.arange(40000).view(1, 200, 200)\n",
    "# 最终得到2组roi的结果\n",
    "RoIAlign(BBoxes, feature_map, n=7).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了便于读者理解上述流程，我们用一幅图来代替网络中的feature map，以此对RoI Align操作进行可视化。如图6-6所示，在这幅图中我们框出了八个字母，作为RoI Align处理的对象。为了保证可视化结果更加直观，我们将最后聚合得到的结果从7×7调大，以便观察。输出结果如图6-7、图6-8所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=1259x1029 at 0x7F91A499A390>"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch as t\n",
    "from PIL import Image\n",
    "from torchvision.transforms.functional import to_tensor, to_pil_image\n",
    "\n",
    "# 读取一张图像，模拟RoI Align操作\n",
    "img = Image.open('./imgs/ROI.png')\n",
    "img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = to_tensor(img)\n",
    "# 框出图像中的8个字母，依次从左往右、从上往下\n",
    "BBoxes = t.tensor([[90, 150, 280, 320],[88, 540, 280, 690], [88, 915, 280, 1062],\n",
    "                  [420, 157, 625, 315],[415, 540, 625, 675], [420, 930, 625, 1060],\n",
    "                  [735, 320, 937, 485], [735, 755, 935, 918]])\n",
    "# 得到目标区域的池化结果，将n调至50便于观察\n",
    "rois = RoIAlign(BBoxes, img, n=50)\n",
    "\n",
    "def show_img(img):\n",
    "    return to_pil_image(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGBA size=50x50 at 0x7F91A49A8940>"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_img(rois[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGBA size=50x50 at 0x7F91A49A8E10>"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_img(rois[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.4.3 反向Unique\n",
    "\n",
    "在PyTorch中有一个`unique`函数，它的功能是返回输入Tensor中不同的元素组成的unique list，同时返回输入Tensor对应于这个unique list的索引。当我们拿到了这个unique list和对应的索引，我们能不能还原出输入的Tensor呢？\n",
    "\n",
    "答案是肯定的。我们可以遍历这个索引，逐个生成输入Tensor对应位置的元素，最后进行组合即可。这个过程比较繁琐，我们可以考虑使用高级索引解决这个问题。根据6.3.3节中整数数组索引的思路，这个索引的size和目标Tensor的size是一致的，因此我们可以直接使用整数数组索引对原始Tensor进行构建，具体实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机生成一组形状为(10, 15, 10, 5)、0~9数字组成的张量\n",
    "a = t.randint(1, 10, (10, 15, 10, 5))\n",
    "# 获取输出的unique list和索引\n",
    "output, inverse_indices = t.unique(a, return_inverse=True)\n",
    "# 通过整数数组索引 还原原始tensor\n",
    "a_generate = output[inverse_indices]\n",
    "\n",
    "a_generate.equal(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看出，还原的Tensor值与原始值一致，这意味着使用高级索引方法可以便捷地完成反向unique操作，从而避免了耗时较长的循环遍历操作。\n",
    "\n",
    "## 6.5 小结\n",
    "\n",
    "本章对PyTorch中的向量化计算与高级索引进行了详细介绍。向量化思想在高维数据处理时能够有效提升计算效率，高级索引操作可以帮助我们灵活地对Tensor进行取值、切片等操作，以便进行更加复杂的计算。同时，本章通过三个示例说明了向量化思想在实际场景中的应用，读者应该仔细体会其中的向量化思想，并在解决实际问题时尝试使用向量化思想进行编程，从而提高程序的运行效率。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch1.6",
   "language": "python",
   "name": "torch1.6"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.2"
  },
  "metadata": {
   "interpreter": {
    "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
